/*
 * @Author: yuqy
 * @Date: 2022-07-04 16:01:20
 * @LastEditors: yuqy
 * @LastEditTime: 2023-10-24 16:54:03
 * @Descripttion: -
 */

// socket 传递的消息类型
// type标记消息类型 
// 9: 心跳  1: 申请发言 2: 允许申请发言  3： 禁止申请发言  
// 4: 讲师主动禁言  886： 老师退出课堂  88：听众退出课堂
// 100 讲师主动加入房间 101 观众加入课堂
// 6 主讲老师开启互动白板
// 7 主讲老师关闭互动白板
// 704 主讲老师禁止某个讲师书写
// 705 主讲老师允许某个讲师书写
//  {
//   type: '9', 
//   to: '15141', // 发送到，指定的个人 (0 是发送给所有人， 手机号就指定到个人)
//   user: '25141' // 当前发送信息的个人 目前截取用户的uid
// }
/* eslint-disable */
import { mapState, mapActions, mapMutations } from 'vuex'
import { Toast } from 'vant'
import { Message } from 'view-ui-plus'
import util from '@/libs/util'
// socket 重连次数
let reLinkNum = 0
let pageName = null
export default {
  data() {
    return {
      ws: null,
      isLinkNow: false,
      teacherActiveTime: null, // 教师活跃时间
      sendMsgToaudienceEr: null,
      lecturerOnline: false, // 讲师是否在线
    }
  },
  computed: {
    ...mapState({
      webSocketUrl: (state) => state.APP_WEB_SOCKET_URL, // websocket 通信地址
      userInfo: (state) => state.user.userInfo, 
    }),
    // 主讲老师页面
    isHomeSpeaker: () => {
      return pageName == 'homeSpeaker';
    },
    // 听讲老师页面
    isListenSpeaker: () => {
      return pageName == 'listenSpeaker';
    },
  },
  created() {
    pageName = this.$route.name
  },
  unmounted() {
    this.clearSocket()
  },
  methods: {
    ...mapActions('user', ['getUserInfo']),
    ...mapMutations('roomAgora', ['updateSreenUser']),
    getNowTime() {
      if (!this.isGetNowTime) return
      let timeStamp = new Date().getTime()
      this.nowTimeText = util.format(timeStamp, 'yyy-MM-dd HH:mm:ss')
      setTimeout(() => {
        this.getNowTime()
      }, 1000)
    },
    /**
     * @name: 初始化socket链接
     * @msg: 
     * @return {*}
     */
    startWebSocketInit() {
      console.log('start link websocket')
      if (this.ws) return
      if (!this.code) return
      try {
        this.ws = new WebSocket(this.webSocketUrl + this.code)
        // 获取链接状态
        this.ws.onopen = () => {
          console.log('websocket success')
          this.socketText = '链接状态' + this.ws.readyState
          this.isLinkNow = true
          reLinkNum = 0
          this.socketText = '正在发送心跳'
          // 主讲老师，加入课堂
          if (pageName == 'homeSpeaker') {
            this.sendTeacherInOut("100")
            this.sendHeart();
          } else {
            // 观众加入课堂 不主动发，只有检测到讲师在线后，才需要发送
            this.sendTeacherInOut("101")
            // this.lecturerOnline = false
            // this.sendHeart(10);
            // this.sendCommonMsg('101');
            // this.teacherActiveTime = Date.now();
          }
        }

        this.ws.onmessage = (data) => {
          this.getMsg(data.data)
        }

        this.ws.onclose = () => {
          this.ws = null
          this.isLinkNow = false
          if (reLinkNum > 10) { // 30秒内连不上，就不再尝试链接
            console.log('websocket 长时间链接故障，请稍后重试!')
            // this.$Notice.error({ title: "提示", desc: "websocket 长时间链接故障，请稍后重试!" })
            Message.error({ content: 'websocket 长时间链接故障，请稍后重试!', duration: 3 })
            return reLinkNum = 0
          }
          // 关闭后，需要3秒后重新链接
          setTimeout(() => {
            reLinkNum++
            this.startWebSocketInit()
          }, 1000 * 3)
        }

        this.ws.onerror = (error) => {
          console.log(error)
          Message.error({ content: 'websocket error!', duration: 3 })
        }
      } catch (error) { }
    },
    clearSocket() {
      reLinkNum = 0
      this.isLinkNow = false
      this.teacherActiveTime = null // 教师活跃时间
      this.sendMsgToaudienceEr = null
      this.lecturerOnline = false // 讲师是否在线
      if (this.ws) {
        this.ws.onerror = null
        this.ws.onclose = null
        this.ws.close()
        this.ws = null
      }
    },
    /**
     * @name: 是否需要发送心跳
     * @msg: 
     * @param {*} time 默认频率3秒一次
     * @return {*}
     */
    sendHeart(time = 5) {
      if (!this.isLinkNow) return;
      // let nowTime = new Date().getSeconds()
      let data = {
        type: "9",
        to: this.toUid, // 目标接收人, 听众发给讲师 讲师发给所有人
        user: this.uid
      }
      //  是否开启互动画板 以及当前画板书写状态是否禁用
      if (pageName == 'homeSpeaker' && this.isOpenWhiteboard) {
        data.openBoard = this.isOpenWhiteboard
        data.isWrite = this.isAllWrite
      }
      this.sendMsgText = JSON.stringify(data)
      this.ws.send(this.sendMsgText)
      // 听讲老师，主动刷新主讲老师状态
      this.refreshTeacherStatus()
      // 主讲老师可以发送心跳
      setTimeout(() => {
        this.sendHeart(time)
      }, 1000 * time)
    },
    // 需要对发送过来的数据进行转化
    getDataChange(data) {
      if (data == '连接成功') return null
      try {
        return JSON.parse(data)
      } catch (error) {
        return null
      }
    },
    // 接受到服务器来的信息, 进行相关逻辑的处理
    getMsg(data_) {
      let data = this.getDataChange(data_)
      if (data == null) return
      if (!data.user) return
      // console.log(data)
      // this.getMsgText.push({
      //   time: new Date().getTime(),
      //   con: data
      // })
      try {
        switch (data.type) {
          case '9': // 心跳 在此维护当前房间人员状态
            this.refreshList(data)
            break;
          case '1': // 某个听讲，申请发言
            this.requestSpeak(data)
            break;
          case '2': // 主讲允许某个听讲发言
            this.canSpeak(data)
            break;
          case '201': // 主讲主动发起指令让某个听讲发言
            this.setSomeOneSpeak(data)
            break;
          case '204': // 听讲老师拒绝了主讲老师的发言邀请
            this.someOneNotSpeak(data)
            break;
          case '202': // 听讲老师同意了主讲老师的发言邀请
            this.someOneCanSpeak(data)
            break;
          case '3': // 主讲禁止听讲申请发言
            this.notSpeak(data)
            break;
          case '4': // 主讲禁止听讲发言
            this.notSpeak_(data)
            break;
          case '5': // 主讲解除禁止听讲发言，听讲可以继续申请发言
            this.notSpeak_(data)
            break;
          case '6': // 主讲老师开启白板
            this.openFastBoard(data)
            break;
          case '7': // 主讲老师关闭白板
            this.closeFastBoard(data)
            break;
          case '702': // 所有听众都可以书写
            this.allCanFastBoard(data)
            break;
          case '703': // 所有听众都禁止书写
            this.allnotFastBoard(data)
            break;
          case '704': // 主讲老师禁止某个听众书写
            this.notFastBoard(data)
            break;
          case '705': // 主讲老师允许某个听众书写
            this.canFastBoard(data)
            break;
          case '886': // 主讲老师主动退出课堂
            this.teacherOut(data)
            break;
          case '88': // 某个听讲主动退出课堂
            this.someOneOut(data)
            break;
          case '861': // 某个听讲被主讲老师主动给终止互动，并清出房间
            this.setSomeoneOut(data)
            break;
          case '100': // 主讲老师进入课堂
            this.teacherIn(data)
            break;
          case '101': // 观众进入课堂
            this.audienceIn(data)
            break;
          case '102': // 观众主动停止发言课堂
            this.stopSpeak(data)
            break;
          case '404': // 某个听众因为没有摄像头主动像讲师发送没有设备信息
            this.noVideoDec(data)
            break;
          case '401': // 听众发起401以后，如果主讲还未拉取到视频，改变状态
            this.setUserPlayStatus(data)
            break;
          case '409': // 主讲得到相同的多个用户登录后，主动发送指令给听讲，让听讲自己调取接口验证自身哪个被顶掉了
            this.checkListerToken(data)
            break;
          case '889': // 主讲老师正在处于切换，视频源的过程中，此时听众收到老师，退出后，需要弹出提示
            this.teacherChangeVideo(data)
          default:
            break;
        }
      } catch (error) {
        console.log(error)
      }
      // this.getMsgText.push({
      //   con: data,
      //   time: dayjs(new Date().getTime()).format('YYYY-MM-DD hh:mm:ss')
      // })
    },
    // 发送公用消息
    sendCommonMsg(type, to) {
      let data = {
        time: Date.now(),
        type,
        user: this.uid
      }
      // 听众进入，发送个人信息
      if (type == '101') {
        data.name = this.userInfo.name
        data.phone = this.userInfo.phone
        data.schoolName = this.userInfo.schoolName
        data.isLookLive = this.isShowLiveWrap // 标记当前观看类型是否是直播，不是直播就是互动
      }
      // 主讲老师 主动清出去互动听讲
      if (type == '861') {
        this.someoneOutFn(to)
      }
      // 指定个人需要接受的消息
      if (to) { data.to = to }
      if (!this.ws) return;
      this.sendMsgText = JSON.stringify(data)
      this.ws.send(this.sendMsgText)
    },
    /**
     * @name: 所有听众都可以书写
     * @msg: 
     * @return {*}
     */
    allCanFastBoard() {
      if (pageName == 'listenSpeaker') {
        Message.success({ content: '讲师允许所有人参与书写!', duration: 3 })
        try {
          // this.$refs.whiteBoardLister.controlWrite(true)
          this.isCanwrite = true
        } catch (error) {

        }
      }
    },
    // 所有听众都禁止书写
    allnotFastBoard() {
      if (pageName == 'listenSpeaker') {
        Message.error({ content: '讲师禁止所有人参与书写!', duration: 3 })
        try {
          // this.$refs.whiteBoardLister.controlWrite(false)
          this.isCanwrite = false
        } catch (error) {

        }
      }
    },
    /**
     * @name: 主讲老师禁止指定用户书写
     * @msg: 
     * @return {*}
     */
    notFastBoard({ to }) {
      if (to == this.uid && pageName == 'listenSpeaker') {
        // this.$Notice.error({ title: '提示', desc: '讲师禁止你参与书写!' })
        Message.error({ content: '讲师禁止你参与书写!', duration: 3 })
      }
    },
    /**
     * @name: 主讲老师允许指定用户书写
     * @msg: 
     * @return {*}
     */
    canFastBoard({ to }) {
      if (to == this.uid && pageName == 'listenSpeaker') {
        Message.success({ content: '讲师允许你参与书写!', duration: 3 })
      }
    },
    /**
     * @name: 主讲老师开启白板了 主讲端页面需要作出配合反应
     * @msg: 
     * @return {*}
     */
    openFastBoard() {
      if (pageName == 'listenSpeaker') {
        // this.$Notice.success({ title: '提示', desc: '讲师打开互动白板!' })
        Message.success({ content: '讲师打开互动白板!', duration: 3 })
        this.teacherOpenBoard(true)
      }
    },
    /**
     * @name: 主讲老师关闭互动白板了
     * @msg: 
     * @return {*}
     */
    closeFastBoard() {
      if (this.isListenSpeaker) {
        Message.success({ content: '讲师已关闭互动白板!', duration: 3 })
        this.teacherCloseBoard()
      }
    },
    /**
     * @name: 校验token，验证自身是否被顶掉
     * @msg: 
     * @param {*} to
     * @return {*}
     */
    checkListerToken({ to }) {
      if (to == this.uid && this.isListenSpeaker) {
        this.checkSelfToken()
      }
    },
    // 通过刷新用户信息接口校验自身token是否过期,
    checkSelfToken() {
      localStorage.isCheckSelfToken = true
      this.getUserInfo()
    },
    /**
     * @name: 观众进入课堂 
     * @msg: 
     * @param {*} data
     * @return {*}
     */
    audienceIn(data) {
      if (pageName != 'homeSpeaker') return // 只有主讲老师才需要
      let nowTimeStamp = Date.now()
      let isHas = false
      let sreenUserList = this.sreenUserList.map(s => {
        if (s.uid == data.user) {
          isHas = true
          if (s.activeTimeStamp) { // 说明当前房间已经有这个人了 主讲发出指令让这一个用户主动刷新一个接口，验证到底哪个用户，是被顶掉的
            this.sendCommonMsg('409', data.user)
          }
          s.activeTimeStamp = nowTimeStamp // 用来判断，当前用户，是否处于活跃状态 当前时间戳
        }
        return s
      })
      // 有新的用户加入了
      if (!isHas) {
        sreenUserList.push(
          {
            playStatus: 1,
            name: data.name,
            phone: data.phone,
            schoolName: data.schoolName,
            isLookLive: data.isLookLive, // 当前观众，是否是在观看直播，如果是看直播用户就不要在列表显示
            isfull: false,
            isAudio: false,
            uid: data.user,
            activeTimeStamp: nowTimeStamp,
            isApplySpeak: false
          }
        )
        // 这个时候需要给抬头屏幕，发送消息, 增加简单防刷处理
        if (this.sendMsgToaudienceEr) {
          clearTimeout(this.sendMsgToaudienceEr)
          this.sendMsgToaudienceEr = null
        }
        this.sendMsgToaudienceEr = setTimeout(() => {
          this.sendUserListToAudience()
        }, 1000)
      }
      this.updateSreenUser(sreenUserList);
    },
    /**
     * @name: 讲师，听众 进入进出课堂 理论上只需要发送一次即可
     * @msg: 
     * @param {*} type
     * @return {*}
     */
    sendTeacherInOut(type) {
      this.sendCommonMsg(type)
    },
    /**
     * @name: 主讲老师正在切换视频源头
     * @msg: 
     * @return {*}
     */
    teacherChangeVideo() {
      if (this.uid > 20000) return
      this.teacherIsChangeVideo = true
      // 10秒后更换切换状态
      setTimeout(() => {
        this.teacherIsChangeVideo = false
      }, 1000 * 10)
    },
    /**
     * @name: 主讲老师已经进入课堂，只有观众需要作出反应
     * @msg: 
     * @return {*}
     */
    teacherIn() {
      // 接收到多余主讲进入课堂以后，需要校验自身token
      if (this.isHomeSpeaker) return this.checkSelfToken()
      Message.success({ content: '讲师已进入课堂!', duration: 3 })
      this.lecturerOnline = true
      this.isSendJoinMsg = false
      this.audienceInSendMsg('101')
      this.teacherText = '讲师已进入课堂'
      // 检测声网客户端有没有启动
      this.isCheckClientRun()
    },
    // 主讲老师退出房间，这个时候需要关闭所有声网操作 并给抬头屏幕发一条指令，关闭当前页面
    teacherOut() {
      if (this.uid > 20000) return
      this.lecturerOnline = false
      this.isSendJoinMsg = false
      this.closeALL()
    },
    /**
     * @name: 某个听讲老师 被主讲老师主动清出课堂, 只有对应的听讲老师需要做出反应，由互动模式转为 观看直播模式, 并调取退出课堂接口
     * @msg: 
     * @param {*} user
     * @return {*}
     */
    async setSomeoneOut({ to }) {
      if (to == this.uid) {
        this.$Message.warning({ content: '主讲老师将你，清出房间!', duration: 5 });
        return this.closeALLandLookLive()
      }
      // 讲师，需要讲列表中的  互动用户给清掉
      // if (this.uid > 20000) {
      //   this.someoneOutFn(to)
      // }
    },
    /**
     * @name: 某个听讲老师各种原因 退出列表
     * @msg: 
     * @param {*} userId 推出房间的 用户id
     * @return {*}
     */
    async someoneOutFn(userId, showTip = false) {
      let currentUser = this.sreenUserList.find(user => user.uid == userId)
      if (!!currentUser) {
        // 增加防刷处理
        let sreenUserList = this.sreenUserList.filter((user) => {
          return user.uid != userId
        })
        if (showTip) {
          let content = '听众' + currentUser.name + '已退出课堂!'
          this.$Message.info({ content, duration: 5 });
        }
        this.$store.commit('updateSreenUser', sreenUserList)
        // 通知副屏进行刷新列表动作 增加防刷处理
        if (this.sendMsgToaudienceEr) {
          clearTimeout(this.sendMsgToaudienceEr)
          this.sendMsgToaudienceEr = null
        }
        this.sendMsgToaudienceEr = setTimeout(() => {
          this.sendMsgToaudience({ type: 'userChange' })
        }, 1000)
        // 只有有人员退出的时候，才需要刷新视频列表
        // this.initAgoraList()
      }
    },
    /**
     * @name: 某个听讲老师 退出课堂, 只有主讲老师需要做出反应
     * @msg: 
     * @param {*} user 用户的uid
     * @return {*}
     */
    someOneOut({ user }) {
      // 防止同一个房间存在多个同一账号
      if (user == this.uid) {
        if (this.isOutClass) return // 过滤掉主动退出房间的
        this.$Message.warning({ content: '您已主动退出!', duration: 5 });
        return this.closeALL()
      }
      if (this.isHomeSpeaker) {
        this.someoneOutFn(user, true)
      }
    },
    /**
     * @name:  修改某个用户播放状态状态
     * @msg: 
     * @return {*}
     */
    setUserPlayStatus({ user }) {
      if (this.isHomeSpeaker) {
        let sreenUserList = util.getDeepObg(this.sreenUserList);
        sreenUserList.forEach((element) => {
          if (element.uid == user && element.playStatus == 1) { // 匹配当前房间是否有这个人，以及当前播放状态
            element.playStatus = 401
          }
        });
        this.updateSreenUser(sreenUserList)
      }
    },
    /**
     * @name: 某个观众没有摄像头设备
     * @msg: 
     * @return {*}
     */
    noVideoDec({ user }) {
      if (this.isHomeSpeaker) {
        let sreenUserList = util.getDeepObg(this.sreenUserList);
        sreenUserList.forEach((element) => {
          if (element.uid == user) { // 匹配当前房间是否有这个人
            element.playStatus = 404
          }
        });
        this.updateSreenUser(sreenUserList)
      }
    },
    /**
     * @name: 某个用户中止发言
     * @msg: 
     * @param {*} user
     * @return {*}
     */
    stopSpeak({ user }) {
      if (this.isHomeSpeaker) {
        let sreenUserList = util.getDeepObg(this.sreenUserList);
        sreenUserList.forEach(element => {
          if (element.uid == user) { // 匹配当前房间是否有这个人
            element.isAudio = false
            element.isNotSay = false
            element.isApplySpeak = false // 是否处于申请发言状态
          }
        });
        this.updateSreenUser(sreenUserList)
      }
    },
    // 主讲老师禁止发言 与 解除禁止操作
    notSpeak_({ to, type }) {
      if (to == this.uid) {
        if (type == 4) {
          this.audioValue = 4
          this.isAudioing = false
          Message.warning({ content: '讲师，禁止你发言!', duration: 5 });
          this.stopGetAudio()
        }
        if (type == 5) {
          this.audioValue = 0
          this.isAudioing = false
          Message.success({ content: '讲师，已解除禁言状态!', duration: 5 });
        }
      }
    },
    // 主讲老师拒绝发言申请
    notSpeak({ user, to }) {
      if (to == this.uid) {
        this.audioValue = 0
        Message.warning({ content: '讲师，拒绝了你的发言申请!' });
      }
    },
    // 主讲老师主动指定某个听讲开始发言
    setSomeOneSpeak({ user, to }) {
      if (this.uid == to) {
        // 主动进行发言，不需要进行询问
        this.audioValue = 6
        this.isAudioing = true
        this.sendCommonMsg('202')
        this.getLocalAudio()
        // Dialog.confirm({
        //   cancelButtonText: '拒绝',
        //   confirmButtonText: '开始发言',
        //   title: "主讲老师正邀请您发言", message: '是否发言？', confirmButtonColor: '#fe6400'
        // }).then(() => {
        //     // 主动进行了发言
        //     this.audioValue = 6
        //     this.isAudioing = true
        //     this.sendCommonMsg('202')
        //     this.getLocalAudio()
        //   }).catch(() => {
        //     // 拒绝了主讲老师
        //     this.sendCommonMsg('204')
        //   })
      }
    },
    // 听讲老师拒绝了发言邀请 只有主讲需要处理该信息
    someOneNotSpeak({ user }) {
      if (this.isHomeSpeaker) {
        let sreenUserList = this.sreenUserList
        sreenUserList.forEach(element => {
          if (element.uid == user) {
            let content = '听众' + element.name + '已拒绝!';
            Message.warning({ content });
          }
        });
      }
    },
    // 听讲老师选择了同意发言邀请 只有主讲需要处理该信息
    someOneCanSpeak({ user }) {
      if (this.isHomeSpeaker) {
        let sreenUserList = util.getDeepObg(this.sreenUserList);
        sreenUserList.forEach(element => {
          if (element.uid == user) { // 匹配当前房间是否有这个人
            element.isAudio = true
            element.isNotSay = false
            element.isApplySpeak = false // 是否处于申请发言状态
            this.audioValue = 0
          }
        });
        this.updateSreenUser(sreenUserList)
      }
    },
    // 可以进行发言 找到当前听众
    canSpeak({ user, to }) {
      if (this.uid == to) {
        this.audioValue = 2
        this.isAudioing = true
        // this.$Notice.success({ title: '提示', desc: '讲师审批通过，请发言!' })
        Message.success({ content: '讲师审批通过，请发言!', duration: 5 });
        this.getLocalAudio()
        return
      }
    },
    // 申请发言 只需要接收一个uid 找到当前讲师，用户
    requestSpeak({ user, to }) {
      if (this.isHomeSpeaker) {
        let sreenUserList = util.getDeepObg(this.sreenUserList)
        sreenUserList.forEach(element => {
          if (element.uid == user) { // 匹配当前房间是否有这个人
            element.isAudio = false
            element.isNotSay = false
            element.isApplySpeak = true // 是否处于申请发言状态
          }
        });
        this.updateSreenUser(sreenUserList);
      }
    },

    /**
     * @name: 可以发言，发送确认心跳或者拒绝，禁止。-> 2 允许发言 3，拒绝发言申请 4 禁止发言 861 主动踢出课堂
     * @msg: 
     * @param {*} uid
     * @param {*} type
     * @return {*}
     */
    confirmCancelReq(uid, type) {
      let data = {
        time: new Date().getTime(),
        type,
        to: uid,
        user: this.uid
      }
      // alert(type)
      this.sendMsgText = JSON.stringify(data)
      this.ws.send(this.sendMsgText)
      let sreenUserList = util.getDeepObg(this.sreenUserList)
      sreenUserList.forEach(element => {
        if (element.uid == uid) { // 匹配当前房间是否有这个人
          element.isApplySpeak = false // 是否处于申请发言状态
          element.isNotSay = false
          if (type == 2) {
            element.isAudio = true // 允许发言
          }
          if (type == 3) {
            element.isAudio = false
          }
          if (type == 4) {
            element.isNotSay = true
            element.isAudio = false // 主动禁止发言
          }
          if (type == 5) { // 主动解除禁止发言状态，此时听众可以继续申请发言
            element.isNotSay = false
            element.isAudio = false
          }
        }
      });
      this.updateSreenUser(sreenUserList);
    },

    /**
     * @name: 听众发送加入房间信息
     * @msg: 
     * @param {*} type
     * @return {*}
     */
    audienceInSendMsg(type) {
      if (this.isSendJoinMsg) return
      this.isSendJoinMsg = true
      if (type == '101' && !this.token) { // 没有声网信息才需要重新获取
        // this.getRoomD(this.code) 
      }
      this.sendCommonMsg(type)
    },
    /**
     * @name: 获取的实时心跳信息，不同角色可对当前房间进行相应处理
     * @msg: 
     * @param {*} user 发送心跳的讲师，大于20000是主讲 小于是听众
     * @return {*}
     */
    refreshList({ user, openBoard, isWrite }) {
      // 只有讲师才需要
      if (pageName == 'homeSpeaker') {
        // let nowTimeStamp = new Date().getTime()
        // if (user < 20000) {
        //   this.sreenUserList.forEach(element => {
        //     if (element.uid == user) { // 匹配当前房间是否有这个人
        //       element.activeTimeStamp = nowTimeStamp // 更新用户活跃时间
        //     }
        //   });
        //   return 
        // }
        // let sreenUserList = JSON.parse(JSON.stringify(this.sreenUserList))
        // sreenUserList.forEach((element, index) => {
        //   // 20秒内没有发送心跳的，判断为已退出房间用户
        //   if (element.activeTimeStamp && element.activeTimeStamp <= nowTimeStamp - 20 *1000) {
        //     console.log('有用户心跳超过20秒没有发')
        //     sreenUserList.splice(index, 1) // 删除该用户
        //     // 这个时候需要给抬头屏幕，发送消息, 并重新拉取列表
        //     setTimeout(() => {
        //       this.sendMsgToaudience({ type: 'userChange' })
        //       this.initAgoraList()
        //     }, 1000)
        //   }
        // });
        // this.$store.commit('updateSreenUser', sreenUserList)
        return
      }
      // 以下所有操作主讲页面，都不要进行
      if (pageName == 'homeSpeaker') return
      // 听讲的心跳主动过滤
      if (user * 1 <= 20000) return
      // 标记讲师 是否在线 首次收到主讲老师进入课堂后，需要发送心跳
      if (!this.lecturerOnline) {
        this.teacherText = '讲师已进入课堂'
        this.lecturerOnline = true
        setTimeout(() => {
          this.audienceInSendMsg('101')
        }, 2000)
        // 给主讲老师 20s的时间，用来拉取听讲推送的视频流
        setTimeout(() => {
          this.audienceInSendMsg('401')
        }, 1000 * 20)
        // 开始监听讲师心跳状态
        this.refreshTeacherStatus()
        // 开始推拉流操作，确认主讲老师在线以后
        // this.initAgora({ mode: "live" })
      }
      // 记录讲师的心跳的时间 
      this.teacherActiveTime = new Date().getTime()
      //  主讲已经打开了互动白板
      if (openBoard) {
        this.teacherOpenBoard(isWrite)
      }
      //  主讲已经关闭了互动白板
      // if (!openBoard) {
      //   this.teacherCloseBoard()
      // }
    },
    // 听讲端实时刷新讲师的状态 仅仅听讲端页面需要运行
    refreshTeacherStatus() {
      if (this.pageName != 'listenSpeaker') return
      if (!this.isRefreshTeacherStatus) return
      // 如果主讲老师不在线，直接return
      if (!this.lecturerOnline) return
      let nowTime = new Date().getTime()
      let disTime = nowTime - this.teacherActiveTime // 当前时间，与主讲老师最后一次心跳发送时间点之间的时间差
      // 主讲老师，20秒内没有发出心跳，就认定主讲老师已经退出课堂，这个时候主动停止推流并关闭客户端
      if (disTime > 1000 * 20) this.closeALL()
    },
    /**
     * @name: 主讲老师不在线以后主动关闭所有心跳，推流操作
     * @msg: 
     * @return {*}
     */
    closeALL(desc) {
      if (desc) {
        // this.$Notice.warning({ title: '提示', desc })
        Message.warning({ content: desc, duration: 5 });
      }
      this.teacherText = '讲师已退出课堂'
      this.lecturerOnline = false
      this.closeAllClient()
    },
    /**
     * @name: 被终止互动 并清出课堂，转到观看直播模式
     * @msg: 
     * @return {*}
     */
    async closeALLandLookLive() {
      this.closeClient()
      this.clearSocket()
      // await getAction("/whiteboardclient/interaction/outToClassroom?code=" + this.code, {})
      this.getLiveInfo()
    },
    async closeAllClient() {
      if (this.pageName == 'homeSpeaker') {
        this.sendMsgToaudience({ type: 'close' })
      }
      await this.closeClient()
      this.clearSocket()
      setTimeout(() => {
        // 客户端直接退出当前页面，并关闭客户端
        if (!this.APP_IS_Web) {
          window.electronAPI.resize('close', {})
        }
      }, 1000)
    }
  }
}
